package com.qianying.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.qianying.comment.CommonResult;
import com.qianying.entity.SysRole;
import com.qianying.mapper.SysRoleMapper;
import com.qianying.service.SysRoleService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 * 系统角色表 服务实现类
 * </p>
 *
 * @author check
 * @since 2025-07-15
 */
@Service
public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> implements SysRoleService {

    @Autowired
    SysRoleMapper roleMapper;


    /**
     * 分页查询角色列表
     */
    @Override
    public CommonResult<IPage<SysRole>> getPage(Page<SysRole> page, SysRole sysRole) {
        LambdaQueryWrapper<SysRole> queryWrapper = new LambdaQueryWrapper<>();

        // 角色名称模糊查询
        if (StringUtils.hasText(sysRole.getRoleName())) {
            queryWrapper.like(SysRole::getRoleName, sysRole.getRoleName());
        }

        // 角色编码精确查询
        if (StringUtils.hasText(sysRole.getRoleCode())) {
            queryWrapper.eq(SysRole::getRoleCode, sysRole.getRoleCode());
        }

        // 状态精确查询
        if (sysRole.getStatus() != null) {
            queryWrapper.eq(SysRole::getStatus, sysRole.getStatus());
        }

        // 按排序号升序排序
        queryWrapper.orderByAsc(SysRole::getSort);

        // 执行分页查询
        IPage<SysRole> resultPage = roleMapper.selectPage(page, queryWrapper);

        // 填充状态名称
        resultPage.getRecords().forEach(role -> {
            role.setStatusName(role.getStatus() == 0 ? "启用" : "禁用");
        });

        return CommonResult.success(resultPage);
    }

    /**
     * 根据ID查询角色详情
     */
    @Override
    public CommonResult<SysRole> getByRoleId(Long id) {
        // 空值校验
        if (id == null) {
            return CommonResult.failed("ID不能为空");
        }

        // 查询数据
        SysRole role = roleMapper.selectById(id);
        if (role == null) {
            return CommonResult.failed("未找到ID为" + id + "的角色");
        }

        // 填充状态名称
        role.setStatusName(role.getStatus() == 0 ? "启用" : "禁用");
        return CommonResult.success(role);
    }

    /**
     * 新增角色
     */
    @Override
    public CommonResult<?> saveRole(SysRole sysRole) {
        // 空值校验
        if (sysRole == null) {
            return CommonResult.failed("提交的数据不能为空");
        }

        // 主键ID必须为空（自增）
        if (sysRole.getId() != null) {
            return CommonResult.failed("新增操作ID必须为空");
        }

        // 必传字段校验
        if (!StringUtils.hasText(sysRole.getRoleName())) {
            return CommonResult.failed("角色名称不能为空");
        }
        if (!StringUtils.hasText(sysRole.getRoleDesc())) {
            return CommonResult.failed("角色描述不能为空");
        }
        if (!StringUtils.hasText(sysRole.getRoleCode())) {
            return CommonResult.failed("角色英文code不能为空");
        }

        // 校验角色编码唯一性
        LambdaQueryWrapper<SysRole> codeWrapper = new LambdaQueryWrapper<>();
        codeWrapper.eq(SysRole::getRoleCode, sysRole.getRoleCode());
        if (roleMapper.selectCount(codeWrapper) > 0) {
            return CommonResult.failed("角色编码已存在");
        }
        sysRole.setId(null);
        // 执行新增
        int rows = roleMapper.insert(sysRole);
        return rows > 0 ? CommonResult.success("新增角色成功") : CommonResult.failed("新增角色失败");
    }

    /**
     * 更新角色
     */
    @Override
    public CommonResult<?> updateRole(SysRole sysRole) {
        // 空值校验
        if (sysRole == null) {
            return CommonResult.failed("提交的数据不能为空");
        }

        // ID不能为空
        if (sysRole.getId() == null) {
            return CommonResult.failed("ID不能为空");
        }

        // 必传字段校验
        if (!StringUtils.hasText(sysRole.getRoleName())) {
            return CommonResult.failed("角色名称不能为空");
        }
        if (!StringUtils.hasText(sysRole.getRoleDesc())) {
            return CommonResult.failed("角色描述不能为空");
        }
        if (!StringUtils.hasText(sysRole.getRoleCode())) {
            return CommonResult.failed("角色英文code不能为空");
        }

        // 校验数据存在性
        SysRole existing = roleMapper.selectById(sysRole.getId());
        if (existing == null) {
            return CommonResult.failed("未找到ID为" + sysRole.getId() + "的角色");
        }

        // 校验角色编码唯一性（排除当前ID）
        LambdaQueryWrapper<SysRole> codeWrapper = new LambdaQueryWrapper<>();
        codeWrapper.eq(SysRole::getRoleCode, sysRole.getRoleCode())
                .ne(SysRole::getId, sysRole.getId());
        if (roleMapper.selectCount(codeWrapper) > 0) {
            return CommonResult.failed("角色编码已存在");
        }

        // 执行更新
        int rows = roleMapper.updateById(sysRole);
        return rows > 0 ? CommonResult.success("更新角色成功") : CommonResult.failed("更新角色失败");
    }

    /**
     * 更新角色状态
     */
    @Override
    public CommonResult<?> updateStatus(Integer id, Integer status) {
        // 空值校验
        if (id == null) {
            return CommonResult.failed("ID不能为空");
        }
        if (status == null || (status != 0 && status != 1)) {
            return CommonResult.failed("状态值无效，必须为0（启用）或1（禁用）");
        }

        // 校验数据存在性
        SysRole existing = roleMapper.selectById(id);
        if (existing == null) {
            return CommonResult.failed("未找到ID为" + id + "的角色");
        }

        // 执行更新
        existing.setStatus(status);
        int rows = roleMapper.updateById(existing);
        return rows > 0 ? CommonResult.success("更新角色状态成功") : CommonResult.failed("更新角色状态失败");
    }

    /**
     * 根据ID删除角色
     */
    @Override
    public CommonResult<?> removeById(Integer id) {
        // 空值校验
        if (id == null) {
            return CommonResult.failed("ID不能为空");
        }

        // 校验数据存在性
        SysRole existing = roleMapper.selectById(id);
        if (existing == null) {
            return CommonResult.failed("未找到ID为" + id + "的角色");
        }

        // 执行删除
        int rows = roleMapper.deleteById(id);
        return rows > 0 ? CommonResult.success("删除角色成功") : CommonResult.failed("删除角色失败");
    }

    /**
     * 查询所有角色（不分页）
     */
    @Override
    public CommonResult<List<SysRole>> getAll() {
        LambdaQueryWrapper<SysRole> queryWrapper = new LambdaQueryWrapper<>();
        // 按排序号升序排序
        queryWrapper.orderByAsc(SysRole::getSort);

        // 查询所有数据
        List<SysRole> roleList = roleMapper.selectList(queryWrapper);

        // 填充状态名称
        roleList.forEach(role -> {
            role.setStatusName(role.getStatus() == 0 ? "启用" : "禁用");
        });

        return CommonResult.success(roleList);
    }

    /**
     * 将角色列表转换为简化Map（key:角色ID, value:角色名称）
     */
    @Override
    public CommonResult<Map<Long, String>> getRoleNameMap() {
        // 复用查询逻辑，获取启用的角色
        LambdaQueryWrapper<SysRole> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(SysRole::getStatus, 0)
                .orderByAsc(SysRole::getSort);

        List<SysRole> roleList = baseMapper.selectList(queryWrapper);

        // 转换为Map<角色ID, 角色名称>
        Map<Long, String> roleNameMap = roleList.stream()
                .collect(Collectors.toMap(
                        SysRole::getId,          // key为角色ID
                        SysRole::getRoleName,    // value为角色名称
                        (existing, replacement) -> existing
                ));

        return CommonResult.success(roleNameMap);
    }
}
